//
// Created by Administrator on 2025/9/18.
//

#include<iostream>
#include "../Header/MyClass.h"
namespace MyCPP{

    class A{
        //  常数据成员，const修饰类的成员变量，表示成员常量，不能被修改，
        //  同时它只能在初始化列表中赋值(C11中支持类中实始化)。可被const和非const成员函数调用，而不可以修改。
    public:
        A():x(100),iValue(199){}
    private:
        const int iValue;

        //  常成员函数(不同于static, 这个是属于实例的）
        //  const 修饰函数的意义
        //  承诺在本函数内部不会修改类内的数据成员，不会调用其他非const成员函数
        //  const修饰函数位置
        //  const修饰函数放在声明之后，实现体之前。
        //  如果const放在其他位置(即放在返回类型附近)会产生不必要的误导
        void Display() const{

        }
    //    const void Display(){}
    //    void const Display(){}


        //  const构成函数重载
    public:
        A(int a):x(199),y(299), iValue(a){}
        void dis() const    //  const对象调用时，优先调用
        {
            std::cout<< "x" << x << std::endl;
            std::cout<< "y" << y << std::endl;
        }
        //  构成重载，非const对象，优先调用
        void dis(){
            y = 200;
            std::cout << "x " << x << std::endl;
            std::cout << "y " << y << std::endl;
        }  //

    private:
        const int x;
        int y;

        //  const函数小结
        //  1.如果const构成函数重载，const对象只能调用const函数，非const对象优先调用非const函数(但不能直接调用const函数， 需要转换成const对象，或者在非const函数中调用const重载)。
        //  2.const函数只能调用const函数，非const函数可以调用const函数。
        //  类体外定义的const成员函数，在定义和声明处都需要const修饰符。


        //  常对象
        //  const对象，只能调用const成员函数
        //  可访问const或非const数据成员，不能修改

        //  const A a1;
        //  a1.dis(1);

        //  static修饰符
        //  声明
        //  static 数据类型 成员变量;   //  在类的内部
        //  初始化
        //  static 类名::静态数据成员 = 初值; //  在类的外部

        //  调用
        //  类名::静态数据成员
        //  类对象.静态数据成员

        //  static小结
        //  1.static成员变量实现了同簇类(继承了同一个父类)对象间信息共享.
        //  2.static成员类外存储，求类大小，并不包含在内.
        //  3.static成员是命名空间属于类的全局变量，存储在data区rw(读写)段。
        //  4.static成员使用时必须实时化，且只能类外初始化。
        //  5.可以通过类名访问，也可以通过对象访问。

        //  static小结
        //  1.静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。
        //  2.静态成员函数只能访问静态数据成员，原因：非静态成员函数，在调用时this指针时被当作参数传进。而静态成员函数属于类，而不属于对象，没有this指针。


        //  指向类成员的指针
        //  C++可以定义一个指针，使其指向类成员或成员函数，然后通过指针来访问类的成员，这包括属性成员的指针和指向成员函数的指针。

        //  指向类数据成员的指针
        //  <数据类型><类名>::*<指针名>
        //  string A::*ptrName;
        //  赋值和初始化
        //  <数据类型><类名>::*<指针名>[=&<类名>::<非静态数据成员>]
        //  string A::*ptrName = &A::name;
        //  指向非静态数据成员的指针在定义时必须和类相关联，在使用时，必须和具体的对象关联。
        //  解引用
        //  由于类不是运行时存在的对象，因此，在使用这类指针时，需要首先指定一个对象，然后通过对象来引用指针所指向的成员、
        //  <类对象名>.*<指向非静态数据成员的指针>
        //  <类对象指针>->*<指向非静态数据成员的指针>
        //  s1.*ptrName;
        //  s2->*ptrName;

        //  指向类成员函数的指针
        //  定义一个指向非静态成员函数的指针必须在三个方面与其指向的成员函数保持一致：参数列表，返回类型，所属类型。
        //  <数据类型>(<类名>::*<指针名>)(<参数列表>)
        //  void (A::*ptrFunc)(int, string) = &A::Show;
        //  a1.*ptrFunc(1, "Tom");
        //  a2->ptrFunc(2, "Aim");

        //  指向类成员指针小结
        //  与普通意义上的指针不一样，存放的是偏移量
        //  指向非静态成员函数时，必须用类名作限定符，使用时则必须用类的实例作限定符。指向静态成员函数时，则不需要使用类名作限定符、
        //  假设A::Func()为静态函数，则s
        //  void (*pFunc)() &A:Func;
    };
}
